package com.xianyuwangyou.taizhangdengji

import android.content.Context
import android.net.Uri
import java.io.File
import java.io.FileOutputStream
import java.io.InputStream

class BackgroundImageManager private constructor() {
    companion object {
        @Volatile
        private var INSTANCE: BackgroundImageManager? = null

        fun getInstance(): BackgroundImageManager {
            return INSTANCE ?: synchronized(this) {
                INSTANCE ?: BackgroundImageManager().also { INSTANCE = it }
            }
        }
    }

    /**
     * 获取背景图片文件路径
     */
    fun getBackgroundImagePath(context: Context): String {
        val file = File(context.filesDir, "background_image.jpg")
        return file.absolutePath
    }

    /**
     * 获取历史背景图片目录
     */
    private fun getHistoryImagesDir(context: Context): File {
        val dir = File(context.filesDir, "history_backgrounds")
        if (!dir.exists()) {
            dir.mkdirs()
        }
        return dir
    }

    /**
     * 获取历史背景图片文件路径
     */
    fun getHistoryImagePath(context: Context, index: Int): String {
        val file = File(getHistoryImagesDir(context), "background_$index.jpg")
        return file.absolutePath
    }

    /**
     * 保存当前背景图为历史图片
     */
    private fun saveCurrentAsHistory(context: Context, index: Int) {
        try {
            if (isBackgroundImageExists(context)) {
                val currentImageFile = File(getBackgroundImagePath(context))
                val historyImageFile = File(getHistoryImagePath(context, index))
                
                // 复制文件
                currentImageFile.inputStream().use { input ->
                    historyImageFile.outputStream().use { output ->
                        input.copyTo(output)
                    }
                }
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    /**
     * 获取历史背景图片路径列表（最多3个）
     */
    fun getHistoryImagePaths(context: Context): List<String> {
        val historyPaths = mutableListOf<String>()
        val historyDir = getHistoryImagesDir(context)
        
        if (historyDir.exists()) {
            for (i in 0..2) {
                val historyFile = File(getHistoryImagePath(context, i))
                if (historyFile.exists()) {
                    historyPaths.add(historyFile.absolutePath)
                }
            }
        }
        
        return historyPaths
    }

    /**
     * 检查背景图片是否存在
     */
    fun isBackgroundImageExists(context: Context): Boolean {
        val file = File(getBackgroundImagePath(context))
        return file.exists()
    }

    /**
     * 保存选择的背景图片
     */
    fun saveBackgroundImage(context: Context, imageUri: Uri): Boolean {
        return try {
            // 保存新图片前，将当前图片保存到历史记录中
            if (isBackgroundImageExists(context)) {
                // 将历史图片向后移动（从后往前处理，避免覆盖）
                for (i in 1 downTo 0) {
                    val oldHistoryFile = File(getHistoryImagePath(context, i))
                    if (oldHistoryFile.exists()) {
                        val newHistoryFile = File(getHistoryImagePath(context, i + 1))
                        if (i + 1 < 3) { // 只保留最近3个历史图片
                            oldHistoryFile.renameTo(newHistoryFile)
                        } else {
                            oldHistoryFile.delete() // 删除最旧的历史图片
                        }
                    }
                }

                // 将当前图片保存为第一个历史图片
                saveCurrentAsHistory(context, 0)
            }
            
            val inputStream = context.contentResolver.openInputStream(imageUri)
            val outputFile = File(getBackgroundImagePath(context))
            
            inputStream?.use { input ->
                FileOutputStream(outputFile).use { output ->
                    input.copyTo(output)
                }
            }
            
            true
        } catch (e: Exception) {
            e.printStackTrace()
            false
        }
    }

    /**
     * 从历史图片设置背景图片（交换当前背景图与选中的历史图片）
     */
    fun setHistoryImageAsBackground(context: Context, historyImagePath: String): Boolean {
        return try {
            val currentFile = File(getBackgroundImagePath(context))
            val selectedHistoryFile = File(historyImagePath)
            
            // 如果当前背景图不存在，直接复制历史图作为当前背景图
            if (!isBackgroundImageExists(context)) {
                selectedHistoryFile.inputStream().use { input ->
                    currentFile.outputStream().use { output ->
                        input.copyTo(output)
                    }
                }
                return true
            }
            
            // 创建临时文件用于交换
            val tempFile = File(getBackgroundImagePath(context) + ".tmp")
            
            // 执行三步交换过程
            // 1. 将当前背景图复制到临时文件
            currentFile.inputStream().use { input ->
                tempFile.outputStream().use { output ->
                    input.copyTo(output)
                }
            }
            
            // 2. 将选中的历史图片复制到当前背景图位置
            selectedHistoryFile.inputStream().use { input ->
                currentFile.outputStream().use { output ->
                    input.copyTo(output)
                }
            }
            
            // 3. 将临时文件（原当前背景图）复制到选中的历史图片位置
            tempFile.inputStream().use { input ->
                selectedHistoryFile.outputStream().use { output ->
                    input.copyTo(output)
                }
            }
            
            // 删除临时文件
            tempFile.delete()
            
            true
        } catch (e: Exception) {
            e.printStackTrace()
            false
        }
    }

    /**
     * 获取背景图片的URI
     */
    fun getBackgroundImageUri(context: Context): String {
        return "file://${getBackgroundImagePath(context)}"
    }
    
    /**
     * 获取历史背景图片的URI
     */
    fun getHistoryImageUri(historyImagePath: String): String {
        return "file://$historyImagePath"
    }
}